"""
情感分析服务
专门负责文本情感分析和情绪提取
使用优化的算法提高分析效率
"""

import logging
from typing import Dict, Tuple, Optional
from ..utils.qinxus_optimizer import (
    extract_qinxus_emotion_optimized, 
    map_emotion_for_tts_optimized,
    batch_extract_emotions
)
from ..utils.text_processor import clean_response_text

logger = logging.getLogger(__name__)


class EmotionAnalyzer:
    """
    情感分析器
    提供多种情感分析方法，支持批量处理
    """
    
    def __init__(self):
        # 情感映射表，用于标准化情感名称
        self.emotion_mapping = {
            "happy": "happy",
            "joy": "happy", 
            "sad": "sad",
            "sadness": "sad",
            "angry": "angry",
            "anger": "angry",
            "fear": "fearful",
            "fearful": "fearful",
            "neutral": "neutral",
            "love": "happy",  # 将爱归类为开心
            "trust": "neutral",
            "anticipation": "neutral"
        }
    
    def extract_qinxus_emotion(self, text: str, use_cache: bool = True) -> Tuple[str, str]:
        """
        从文本中提取qinxus格式的情绪信息
        使用优化算法提高处理速度
        
        Args:
            text: 包含情绪标识的文本
            use_cache: 是否使用缓存
            
        Returns:
            Tuple[str, str]: (纯文本, 情绪)
        """
        if not text:
            return text, "neutral"
        
        try:
            # 使用优化的情绪提取函数
            clean_text, emotion = extract_qinxus_emotion_optimized(text, use_cache)
            
            # 标准化情感名称
            normalized_emotion = self.normalize_emotion(emotion)
            
            logger.debug(f"情绪提取完成: '{emotion}' -> '{normalized_emotion}'")
            return clean_text, normalized_emotion
            
        except Exception as e:
            logger.error(f"情绪提取失败: {e}")
            return text, "neutral"
    
    def normalize_emotion(self, emotion: str) -> str:
        """
        标准化情感名称
        将各种情感表达统一为标准格式
        
        Args:
            emotion: 原始情感名称
            
        Returns:
            str: 标准化后的情感名称
        """
        if not emotion:
            return "neutral"
        
        emotion_lower = emotion.lower().strip()
        return self.emotion_mapping.get(emotion_lower, "neutral")
    
    def map_emotion_for_tts(self, emotion: str) -> str:
        """
        为TTS系统映射情感
        将情感名称转换为TTS系统支持的格式
        
        Args:
            emotion: 原始情感名称
            
        Returns:
            str: TTS系统支持的情感名称
        """
        # 使用优化的映射函数
        mapped_emotion = map_emotion_for_tts_optimized(emotion)
        logger.debug(f"TTS情感映射: '{emotion}' -> '{mapped_emotion}'")
        return mapped_emotion
    
    def analyze_emotion_scores(self, text: str) -> Dict[str, float]:
        """
        分析文本的情感分数
        返回各种情感的强度分数
        
        Args:
            text: 要分析的文本
            
        Returns:
            Dict[str, float]: 情感分数字典
        """
        try:
            # 提取主要情感
            clean_text, main_emotion = self.extract_qinxus_emotion(text)
            
            # 构建情感分数字典
            emotion_scores = {
                "happy": 0.0,
                "sad": 0.0,
                "angry": 0.0,
                "fearful": 0.0,
                "neutral": 0.0
            }
            
            # 设置主要情感的分数
            normalized_emotion = self.normalize_emotion(main_emotion)
            emotion_scores[normalized_emotion] = 1.0
            
            return emotion_scores
            
        except Exception as e:
            logger.error(f"情感分数分析失败: {e}")
            # 返回默认的中性情感
            return {"neutral": 1.0}
    
    def batch_analyze_emotions(self, texts: list) -> list:
        """
        批量分析多个文本的情感
        提高处理效率，减少重复计算
        
        Args:
            texts: 文本列表
            
        Returns:
            list: 分析结果列表，每个元素为(纯文本, 情绪)元组
        """
        try:
            # 使用优化的批量处理函数
            results = batch_extract_emotions(texts)
            
            # 标准化情感名称
            normalized_results = []
            for clean_text, emotion in results:
                normalized_emotion = self.normalize_emotion(emotion)
                normalized_results.append((clean_text, normalized_emotion))
            
            logger.info(f"批量情感分析完成，处理了{len(texts)}个文本")
            return normalized_results
            
        except Exception as e:
            logger.error(f"批量情感分析失败: {e}")
            # 返回默认结果
            return [(text, "neutral") for text in texts]
    
    def clean_text_with_emotion_extraction(self, text: str) -> Tuple[str, str]:
        """
        清理文本并提取情感
        结合文本清理和情感提取功能
        
        Args:
            text: 原始文本
            
        Returns:
            Tuple[str, str]: (清理后的文本, 提取的情感)
        """
        try:
            # 先清理文本
            cleaned_text = clean_response_text(text)
            
            # 再提取情感
            final_text, emotion = self.extract_qinxus_emotion(cleaned_text)
            
            return final_text, emotion
            
        except Exception as e:
            logger.error(f"文本清理和情感提取失败: {e}")
            return text, "neutral"
    
    def is_emotion_text(self, text: str) -> bool:
        """
        检测文本是否包含情感信息
        
        Args:
            text: 要检测的文本
            
        Returns:
            bool: 是否包含情感信息
        """
        if not text:
            return False
        
        # 检查是否包含qinxus格式的情感标识
        return 'qinxus' in text and '{' in text and '}' in text
    
    def get_emotion_confidence(self, text: str) -> float:
        """
        获取情感识别的置信度
        
        Args:
            text: 要分析的文本
            
        Returns:
            float: 置信度（0.0-1.0）
        """
        try:
            if self.is_emotion_text(text):
                # 如果包含明确的情感标识，置信度为1.0
                return 1.0
            else:
                # 基于文本长度和内容复杂度估计置信度
                text_length = len(text.strip())
                if text_length < 10:
                    return 0.3
                elif text_length < 50:
                    return 0.6
                else:
                    return 0.8
        except Exception:
            return 0.5


# 全局情感分析器实例
emotion_analyzer = EmotionAnalyzer() 